/*
task: 递归主符号法解决ac151
author: 李智铭 3022206093
*/
#include <iostream>
#include <string>
#include <stdexcept>
#include <cmath>
#include <cctype>
using namespace std;

string expr;  // 输入的数学表达式
size_t pos;   // 当前解析位置

// 函数声明
void process();
int parseExpression();
int parseTerm();
int parseFactor();
int parsePrimary();
int parseNumber();

// 处理表达式，确保括号配对，并在必要时为负号添加前导0
void process() {
    if (expr[0] == '-') expr = '0' + expr;  // 如果表达式以负号开始，添加前导0
    expr = '(' + expr + ')';  // 在表达式外加上括号，方便处理优先级

    int lcount = 0, rcount = 0;  // 统计左右括号的数量
    for (char ch : expr) {
        if (ch == '(') lcount++;  // 左括号数量
        if (ch == ')') rcount++;  // 右括号数量
    }

    // 如果左括号少，补充左括号
    while (lcount < rcount) {
        expr = '(' + expr;
        lcount++;
    }
    // 如果右括号少，补充右括号
    while (rcount < lcount) {
        expr += ')';
        rcount++;
    }
}

// 解析表达式（加法和减法），处理加减运算
int parseExpression() {
    int result = parseTerm();  // 首先解析项
    while (pos < expr.length()) {
        char op = expr[pos];  // 获取当前运算符
        if (op == '+' || op == '-') {
            pos++;  // 跳过运算符
            int term = parseTerm();  // 解析下一个项
            if (op == '+') {
                result += term;  // 加法
            } else {
                result -= term;  // 减法
            }
        } else {
            break;  // 如果不是加减运算符，结束循环
        }
    }
    return result;
}

// 解析项（乘法和除法），处理乘除运算
int parseTerm() {
    int result = parseFactor();  // 首先解析因子
    while (pos < expr.length()) {
        char op = expr[pos];  // 获取当前运算符
        if (op == '*' || op == '/') {
            pos++;  // 跳过运算符
            int factor = parseFactor();  // 解析下一个因子
            if (op == '*') {
                result *= factor;  // 乘法
            } else {
                result /= factor;  // 除法
            }
        } else {
            break;  // 如果不是乘除运算符，结束循环
        }
    }
    return result;
}

// 解析因子（指数运算）
int parseFactor() {
    int result = parsePrimary();  // 首先解析基本表达式
    while (pos < expr.length()) {
        if (expr[pos] == '^') {  // 如果是指数符号
            pos++;  // 跳过符号
            result = pow(result, parsePrimary());  // 进行幂运算
        } else {
            break;  // 如果不是幂运算符，结束循环
        }
    }
    return result;
}

// 解析基本表达式（处理括号和数字）
int parsePrimary() {
    int result;
    bool negate = false;  // 标记是否为负数
    while (expr[pos] == '-') {  // 如果连续遇到负号，翻转符号
        negate = !negate;
        pos++;
    }
    if (expr[pos] == '(') {  // 如果遇到左括号，递归解析括号内的表达式
        pos++;
        result = parseExpression();
        if (expr[pos] == ')') {  // 确保有匹配的右括号
            pos++;
        } else {
            throw runtime_error("Mismatched parentheses");  // 如果括号不匹配，抛出异常
        }
    } else if (isdigit(expr[pos])) {  // 如果遇到数字，解析数字
        result = parseNumber();
    } else {
        throw runtime_error("Invalid character in expression");  // 如果是非法字符，抛出异常
    }
    return negate ? -result : result;  // 返回负数或正数
}

// 解析数字
int parseNumber() {
    size_t endPos;
    int result = stoi(expr.substr(pos), &endPos);  // 从当前位置开始，解析一个整数
    pos += endPos;  // 更新解析位置
    return result;
}

int main() {
    string expression;
    getline(cin, expression);  // 输入表达式

    expr = expression;  // 设置全局表达式
    pos = 0;  // 重置解析位置
    process();  // 处理表达式的括号和负号
    cout << parseExpression() << endl;  // 输出结果

    return 0;
}